home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 001a / qbser21.zip / QBSERIAL.DOC < prev    next >
Text File  |  1992-02-09  |  32KB  |  673 lines
  1.  
  2.  
  3.  
  4.  
  5.                                  QBserial version 2.10
  6.  
  7.                   Serial I/O Routines for use with QuickBASIC & BC6/7
  8.  
  9.           This library will provide you with serial I/O communications
  10.           routines for use in QuickBASIC 4.x (with or without PDQ), and the
  11.           Microsoft Basic Compiler 7.x Professional Development System. No
  12.           longer are you forced to use the poor communications support
  13.           provided by QB.  This program will allow you to control 8250
  14.           (includes 16450) type communications ports at speeds of up to
  15.           115200 baud. Communication ports 1 - 4, and non-standard addresses
  16.           are supported. You will no longer have problems with the DTR
  17.           signal. DTR is left in the same state it was in when before you
  18.           called this driver, or it can be controlled by your program. The
  19.           serial driver includes XON/XOFF and CTS/RTS handshaking. Serial
  20.           input is interrupt driven, using any IRQ you specify (1 - 7), with
  21.           incoming XOFF flow control (if enabled), or RTS flow control (if
  22.           enabled) to prevent overrunning the input buffer. These are the
  23.           same serial I/O routines used in Sparkware's Qmail door, and the
  24.           User Database System Doors "Query Door" and "Upload Door".
  25.  
  26.           The driver was written with Microsoft's C, and compiled with
  27.           version 6.0a of that compiler. This driver is useable with
  28.           QuickBASIC version 4.x, and Basic Compiler 6.x & 7.x PDS. (With or
  29.           without PDQ). BC 1.x, QuickBASIC 2.x, and 3.x are not supported by
  30.           this driver. The reason is that versions of QuickBASIC prior to 4.0
  31.           do not support the extensive multi-language interface that QB4.x
  32.           has (via the DECLARE statement and Microsoft language extensions).
  33.           Throughout this manual QB will be used to refer to both QuickBASIC
  34.           and the Basic Compilers (6.x & 7.x PDS).
  35.  
  36.           Before the driver can be used, the following DECLARE statements
  37.           must be added to the beginning of your QB program:
  38.  
  39.           DECLARE SUB OpenComm CDECL ALIAS "_open_comm" (BYVAL Port%, BYVAL_
  40.                                IRQ%, BYVAL Wlen%, BYVAL Parity%, BYVAL Baud&,
  41.                                BYVAL HS%) 
  42.           DECLARE SUB CloseComm CDECL ALIAS "_close_comm" () 
  43.           DECLARE FUNCTION WriteChar% CDECL (BYVAL Ascii%) 
  44.           DECLARE FUNCTION ReadChar% CDECL () 
  45.           DECLARE SUB Transmit CDECL ALIAS "_transmit_string" (addr$) 
  46.           DECLARE FUNCTION DataWaiting% CDECL ALIAS "_data_waiting" () 
  47.           DECLARE SUB ClearInputBuffer CDECL ALIAS "_clear_input_buffer" () 
  48.           DECLARE SUB CarrierDetect CDECL ALIAS "_carrier_detect_flag"_
  49.                                     (BYVAL OnOff%) 
  50.           DECLARE FUNCTION CarrierLost% CDECL ALIAS "_carrier_state" ()
  51.           DECLARE SUB DTRcontrol CDECL ALIAS "_dtr" (BYVAL OnOff%)
  52.           DECLARE SUB RTScontrol CDECL ALIAS "_rts" (BYVAL OnOff%)
  53.           DECLARE FUNCTION DriverCopyright% CDECL ()
  54.  
  55.  
  56.  
  57.         QBSERIAL User Manual - V 2.10                              Page 1
  58.  
  59.  
  60.           These declarations specify all the entry points into the serial
  61.           driver, They are in the include file QBSERIAL.DEC. DO NOT change
  62.           them or the driver may not function.
  63.  
  64.           Refer to the included sample programs SIMPLE.BAS & PCBDOOR.BAS,
  65.           they use most of the calls described below.
  66.  
  67.  
  68.  
  69.                                   Port Initialization
  70.  
  71.           OpenComm Port%, IRQ%, Wordlen%, Parity%, Baudrate&, HS%
  72.  
  73.           Port%     This is an integer value. If the specified port is 1 to
  74.                     4, the driver opens that port. If you specify the port as
  75.                     ZERO (0) the driver enters "LOCAL" mode. This allows you
  76.                     to call the driver with data, but the driver won't send
  77.                     anything. This is useful when working with "doors". if
  78.                     you specify the port as any other value, QBserial will
  79.                     use that as the base address for the port. This allows
  80.                     you to work with non-standard I/O addresses. Note however
  81.                     that if you open a non-standard port, you must specify an
  82.                     IRQ value of 1 to 7
  83.  
  84.           IRQ%      Specifies which interrupt to use with this port. If the
  85.                     value of IRQ% is ZERO (0), then the default IRQ values
  86.                     are used (COM1 & COM3 use IRQ4, COM2 & COM4 use IRQ3).
  87.                     This is what most applications will use. Specify an IRQ
  88.                     value of 1 through 7 when you want to use an IRQ value
  89.                     other than the default. Such as when you want to use IRQ7
  90.                     with COM3. NOTE: Be careful when choosing an IRQ value
  91.                     other than the default. Most machines use the other IRQ
  92.                     inputs for other machine functions such as the Hard drive
  93.                     and system clock. QBserial DOES NOT chain the interrupt,
  94.                     it takes it over entirely. If you choose an IRQ that is
  95.                     used for something already, your machine will most
  96.                     certainly operate improperly.
  97.  
  98.           Wordlen%  an integer specifying the word length of the serial data.
  99.                     It has a value of 7 or 8.
  100.  
  101.           Parity%   an integer, 0 = NONE, 1 = ODD, 2 = EVEN.
  102.  
  103.           BaudRate& is a LONG INTEGER representing the desired baud rate.
  104.                     Valid numbers are 0, 300, 1200, 2400, 4800, 9600, 19200,
  105.                     38400, 57600, and 115200. The value you send is NOT
  106.                     checked and I assume you could generate crazy baud rates
  107.                     if desired. 115200 is the absolute maximum rate that can
  108.                     be generated. If you specify a baud rate of ZERO then the
  109.                     serial port is used AS-IS. The rate, word length, &
  110.                     parity are NOT changed. This is useful for door operation
  111.  
  112.  
  113.         QBSERIAL User Manual - V 2.10                              Page 2
  114.  
  115.  
  116.                     since the port is already initialized at the proper
  117.                     settings when you get control.
  118.  
  119.           HS%       an integer specifying the type of handshake you wish to
  120.                     use between the CPU and Modem (or destination device).
  121.                     Valid numbers are: 0 = NO handshake, 1 = XON/XOFF, 2 =
  122.                     CTS/RTS, 3 = XON/XOFF and CTS/RTS.
  123.  
  124.  
  125.                                      Serial Output
  126.  
  127.           To send a string of data out the serial port, you use the
  128.           "Transmit" call as follows:
  129.  
  130.                Temp$ = "Transmit this..."
  131.                Transmit Temp$
  132.  
  133.                     or
  134.  
  135.                Transmit "Send this also...."
  136.  
  137.           If you want to transmit single characters, you can use the
  138.           "WriteChar" function. Transmit calls WriteChar to send the actual
  139.           characters to the port. If you wish to use WriteChar, it has the
  140.           following format:
  141.  
  142.                Status% = WriteChar(Char%)
  143.  
  144.           Char% is the integer value of the character you want to send, it is
  145.           not a string. Status% is an integer returned by WriteChar, it is
  146.           NON-ZERO if the character was actually sent to the port, and ZERO
  147.           if the character was not sent. WriteChar will loop indefinitely on
  148.           CTS hold, XOFF hold, or Transmit Buffer Busy. These loops will exit
  149.           if carrier is lost in FULL or PARTIAL modes and return a ZERO
  150.           status%. WriteChar gives you more low level control of the sending
  151.           of characters, but you must send each character separately and
  152.           monitor its status.
  153.  
  154.           The Transmit function monitors the status of its calls to WriteChar
  155.           and triggers QuickBASIC's User Event trap (UEVENT) if a carrier
  156.           loss occurs in FULL mode. The UEVENT trap (FULL mode) is used by
  157.           default. You can disable the use of this event trap in the event
  158.           you already use the UEVENT trap for something else (PARTIAL mode).
  159.           Therefore, by default, carrier loss detection in your program is
  160.           done with the ON UEVENT GOSUB/UEVENT ON statements. The example
  161.           programs show the use of this method. By default UEVENT is also
  162.           used for catching carrier loss on keyboard input. this is described
  163.           below.
  164.  
  165.  
  166.  
  167.  
  168.  
  169.         QBSERIAL User Manual - V 2.10                              Page 3
  170.  
  171.  
  172.                                       Serial Input
  173.  
  174.           Serial input is managed with three functions: DataWaiting,
  175.           ReadChar, & ClearInputBuffer. DataWaiting is used to test the input
  176.           buffer to see if any characters need to be read from it. ReadChar
  177.           is then called to get the characters. ClearInputBuffer flushes the
  178.           input buffer of any existing characters. Both example programs
  179.           contain a subroutine called "KeyboardInput" that demonstrates the
  180.           use of these calls. It also properly handles input from the local
  181.           and remote keyboards, and can be the routine you use in your
  182.           programs if you wish. Basically the procedure for reading the
  183.           remote keyboard (serial input) is as follows:
  184.  
  185.                IF DataWaiting THEN
  186.                     C$ = CHR$(ReadChar)
  187.                END IF
  188.  
  189.           The DataWaiting function also monitors the state of the carrier
  190.           detect signal and triggers, in FULL mode, the user event trap
  191.           (UEVENT) if carrier is lost. As you can see a singular trap routine
  192.           catches carrier loss on output as well as input. You will notice
  193.           that the "KeyboardInput" subroutine loops using DataWaiting, and as
  194.           such, carrier is constantly checked while waiting for input. If the
  195.           ReadChar function is called when no data is available (as indicated
  196.           by DataWaiting) a NULL character is returned.
  197.  
  198.           If XOFF/XON, CTS/RTS, or BOTH is enabled, then the serial buffer
  199.           will be protected from overfills. When the buffer reaches 75% of
  200.           capacity, an XOFF will be sent on the serial output or RTS will be
  201.           dropped. When the buffer empties out to 25% of capacity, an XON
  202.           will be sent or RTS raised. The capacity of the input buffer is
  203.           2048 bytes.
  204.  
  205.  
  206.                                  Carrier Detect Control
  207.  
  208.           There are three modes of carrier detection: Full, Partial, & None.
  209.           Each has it own distinct use for a particular purpose. The driver
  210.           defaults to FULL carrier detection unless you change it. The
  211.           following call is used to change control modes:
  212.  
  213.                CarrierDetect 0 [or] 1 [or] 2
  214.  
  215.           Specifying a TWO (2) sets carrier detection to FULL. This is the
  216.           default mode. When a loss of carrier occurs while transmitting,
  217.           polling for input data, or sitting in a wait loop (XOFF/XON or
  218.           CTS), the driver will return to the calling program and trip the
  219.           UEVENT flag. Tripping the UEVENT flag causes Basic to go to the
  220.           User Event trap routine (providing ON UEVENT GOSUB/UEVENT ON has
  221.           been set up in the user program). You should use this mode only if
  222.           you want to use the UEVENT trap for carrier loss detection. You
  223.           cannot transmit data (with the Transmit function) in this mode if
  224.  
  225.         QBSERIAL User Manual - V 2.10                              Page 4
  226.  
  227.  
  228.           there is no carrier. You can send characters in this mode with the
  229.           WriteChar function.
  230.  
  231.           Specifying a ONE (1) sets carrier detection to PARTIAL. This mode
  232.           is similar to FULL with the exception that the UEVENT flag is not
  233.           tripped when carrier is lost. This mode should be used if UEVENT is
  234.           used for something else in your program, or you don't wish to
  235.           utilize UEVENT. 
  236.  
  237.           Specifying a ZERO (0) sets carrier detection to NONE. An example of
  238.           this mode would be where "plain Jane" serial I/O is required (such
  239.           as communicating with a "dumb" terminal). In this application there
  240.           are no modem handshake signals (3 wire EIA/RS-232). This mode can
  241.           also be used for talking to a modem when there is no carrier signal
  242.           present (such as dialing and initialization commands). The Transmit
  243.           and WriteChar routines will always transmit data in this mode with
  244.           or without carrier present. Carrier detection must be disabled in
  245.           this mode to prevent calls to Uevent and disable the no carrier
  246.           escape mechanisms built into the XON/XOFF loops. Important: if you
  247.           are using the XOFF/XON protocol in this mode and receive an XOFF
  248.           while transmitting, you will sit forever waiting for an XON. This
  249.           is a normal condition, with the exception that there is no escape
  250.           from this loop other than XON.
  251.  
  252.           Please note that there was an error in documentation in the
  253.           previous version (2.0). With CarrierDetect set to 1 (partial) data
  254.           WOULD NOT be sent if no carrier was present (I had said it would be
  255.           sent). You MUST use mode 0 if you wish to converse with a modem
  256.           that is not currently on-line (has no carrier). Once carrier is
  257.           detected, you would then switch to either mode 1 or 2.
  258.  
  259.                            Carrier Loss Detection by Polling
  260.  
  261.           As mentioned above, by default, the UEVENT trap is used to detect
  262.           when a loss of carrier occurs. There is also a function that allows
  263.           you to detect loss of carrier without using the UEVENT trap. While
  264.           I feel that using UEVENT is the simplest way to catch a carrier
  265.           loss in a program, it is possible that UEVENT might need to be used
  266.           by something else. This function is:
  267.  
  268.                X% = CarrierLost
  269.  
  270.           This function call allows to you to 'poll' for the state of
  271.           carrier. CarrierLost returns a NON-ZERO value when there is NO
  272.           carrier, and a ZERO when there IS carrier. CarrierLost is a real
  273.           time function, it returns the current carrier condition at the time
  274.           of the call. This allows you to code simple IF or DO loops to
  275.           detect loss:
  276.  
  277.                IF CarrierLost THEN
  278.                     ..process carrier loss
  279.                END IF
  280.  
  281.         QBSERIAL User Manual - V 2.10                              Page 5
  282.  
  283.  
  284.  
  285.  
  286.                                   Program Termination
  287.  
  288.           Since "OpenComm" seizes an interrupt vector, this vector needs to
  289.           be restored BEFORE your program ends. If you neglect to restore
  290.           this vector, you could be risking a crash. The routine used to
  291.           reset the vector is: CloseComm. Only use CloseComm if you specified
  292.           a port value of 1, 2, 3, 4, or a non-standard port address in the
  293.           OpenComm call. If you specified a port value of ZERO (Local mode)
  294.           the interrupt vector is NOT grabbed, and does not need to be reset.
  295.           CloseComm also resets any UART registers to their original value.
  296.  
  297.  
  298.  
  299.                                Data Terminal Ready (DTR)
  300.  
  301.           Everybody that has used QuickBASIC's OPEN COMn statement is very
  302.           familiar with the problems of the DTR signal. Apparently Microsoft
  303.           felt that DTR would never be needed after a program terminates.
  304.           Anybody who has ever tried to write a door, or chain from one
  305.           program to another has cursed this decision at some time during
  306.           their programs development. This driver handles the DTR with a
  307.           different view. When you close the comm channel the DTR signal is
  308.           left in the same state it was when you opened the comm channel. For
  309.           door applications, this is a must. 
  310.  
  311.           A function call is provided however that allows your program to
  312.           control the DTR signal:
  313.  
  314.           DTRcontrol 1 [or] 0           ' 0 = DTR OFF, 1 = DTR ON
  315.  
  316.           Additionally when you use DTRcontrol to change the state of the DTR
  317.           signal it also instructs the driver to leave it this way when the
  318.           CloseComm function is called. Remember that the driver leaves DTR
  319.           the way it found it when OpenComm was called. If you used some
  320.           other method to change DTR after OpenComm was called, it would
  321.           automatically return to that original state when you called
  322.           CloseComm. Therefor only DTRcontrol should be used if you wish to
  323.           change the state of DTR.
  324.  
  325.                                  Request To Send (RTS)
  326.  
  327.           Request To Send (RTS) is a hardware flow control signal used to
  328.           tell the remote device to STOP sending data to us. Normally RTS is
  329.           set "on" and data will always flow (or the signal is ignored at the
  330.           remote end). With some communications programs RTS is used to
  331.           temporarily stop a modem from sending data while I/O is done to a
  332.           slow disk. This is especially true with high speed communications
  333.           where there is very little time between interrupts. This function
  334.           is independent of the automatic RTS flow control selected by
  335.           handshake 2 or 3 which tells the remote device to stop sending when
  336.  
  337.         QBSERIAL User Manual - V 2.10                              Page 6
  338.  
  339.  
  340.           the input buffer is almost full. This function allows you to
  341.           manually control the state of RTS so you could, for instance, go
  342.           off and write the data somewhere without fear of loosing data.
  343.  
  344.           RTScontrol 1 [or] 0           ' 0 = RTS OFF, 1 = RTS ON
  345.  
  346.           When you use RTScontrol to change the state of the RTS signal it
  347.           also instructs the driver to leave it this way when the CloseComm
  348.           function is called. The driver leaves RTS the way it found it when
  349.           OpenComm was called. If you used some other method to change RTS
  350.           after OpenComm was called, it will automatically return to that
  351.           original state when you call CloseComm. Therefor only RTScontrol
  352.           should be used if you wish to change the state of RTS. This is
  353.           similar in the way DTRcontrol works.
  354.  
  355.                               Driver Version and Copyright
  356.  
  357.           A function is available to access the drivers version and copyright
  358.           string. This would be used if you wish to display in your final
  359.           product the version of QBserial that your are using, and/or my
  360.           copyright along with yours. In order to access the copyright
  361.           string, the following lines should be added to your Basic program:
  362.  
  363.                     X& = DriverCopyright
  364.                     WHILE (PEEK(X&))
  365.                          CP$ = CP$ + CHR$(PEEK(X&))
  366.                          X& = X& + 1
  367.                     WEND
  368.  
  369.           This places the version/copyright string into string variable CP$.
  370.           This string may now be handled in whatever method you choose.
  371.  
  372.  
  373.                                  Cresent's PDQ Library
  374.  
  375.           An object module for use with PDQ is also included. PDQ does not
  376.           support UEVENT, so all references to UEVENT in the text should be
  377.           ignored. You will need to do carrier checking by polling with the
  378.           CarrierLost function. If you use FULL mode and carrier is lost it
  379.           will operate the same way as PARTIAL mode. The only exception to
  380.           this is the Transmit function, which when in FULL mode, will not
  381.           transmit data.
  382.  
  383.           NOTE:     An additional note for PDQ users. Since PDQ replaces the
  384.                     Microsoft run time libraries, the public variable
  385.                     ACRTUSED is not satisfied during the link stage. A dummy
  386.                     stub file, ACRTUSED.OBJ is included with QBserial to
  387.                     prevent this error from occurring. The next paragraph
  388.                     explains the proper linking sequence.
  389.  
  390.  
  391.  
  392.  
  393.         QBSERIAL User Manual - V 2.10                              Page 7
  394.  
  395.  
  396.                                         Linking
  397.  
  398.           Since object modules are provided for QB4.x, BC7, and PDQ, you will
  399.           need to select which one to use for your program. The file
  400.           QBSER.OBJ should be used for programs compiled with QuickBASIC,
  401.           BC7SER.OBJ is to be used for programs compiled with BC7 PDS, and
  402.           QBSERPDQ.OBJ is for PDQ users. Typical link command lines would
  403.           look like this: (Please note that your command lines will probably
  404.           be different if you use additional libraries to generate your code)
  405.  
  406.           Link yourprog qbser;               (For QuickBASIC)
  407.  
  408.           Link yourprog bc7ser;              (For BC7 PDS)
  409.  
  410.           Link yourprog qbserpdq acrtused;   (For PDQ)
  411.  
  412.  
  413.  
  414.                                     Quick Libraries
  415.  
  416.           If you wish to develop programs from within the environment, you
  417.           will first need to create a Quick library using one of the object
  418.           modules QBSER.OBJ, BC7SER.OBJ, or QBSERPDQ.OBJ. To create a Quick
  419.           lib for QuickBASIC 4.x, use the following Link command:
  420.  
  421.                Link QBSER,,,BQLB4x/q
  422.  
  423.           Where "BQLB4x" is one of the following: BQLB40.LIB, BQLB41.LIB, or
  424.           BQLB45.LIB. Use the one that came with your compiler. If you use
  425.           the wrong BQLB file you might get an "Invalid Format" error when
  426.           attempting to start QuickBASIC. QBSER.OBJ may also be added to
  427.           Quick Libraries containing other routines and OBJ's as well.
  428.  
  429.           To create a Quick Library for use within QBX (BC7's environment)
  430.           use the following link command (be sure to use Link v5.xx that came
  431.           with BC7):
  432.  
  433.                Link BC7SER,,,QBXQLB/q;
  434.  
  435.           For PDQ, use the method for QB4.x, since you will be using the
  436.           built in run time routines built into the environment. You ONLY use
  437.           QBSERPDQ.OBJ when you link the EXEcutable file.
  438.  
  439.           Remember too, that you can also add BC7SER.OBJ to Quicklibs
  440.           containing other routines.
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.         QBSERIAL User Manual - V 2.10                              Page 8
  450.  
  451.  
  452.                                      Specifications
  453.  
  454.           The following port addresses and default interrupts are used:
  455.  
  456.                Comm      Base Address        IRQ (Default)
  457.  
  458.                 1          3F8 hex            4
  459.                 2          2F8 hex            3
  460.                 3          3E8 hex            4
  461.                 4          2E8 hex            3
  462.  
  463.           Please read the section explaining the OpenComm function for
  464.           information on how to use addresses or IRQ's other than the
  465.           defaults.
  466.  
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481.  
  482.  
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499.  
  500.  
  501.  
  502.  
  503.  
  504.  
  505.         QBSERIAL User Manual - V 2.10                              Page 9
  506.  
  507.  
  508.                                 Registration and Support
  509.  
  510.           QBserial is distributed as shareware. You may copy and distribute
  511.           it freely. 
  512.  
  513.           QBserial is not free software, and requires registration. There are
  514.           two classes of registration which are dependant upon use:
  515.           Commercial and Non-Commercial.
  516.  
  517.           Registration of QBserial is $25 for non-commercial use. Non-
  518.           commercial uses are: Personal use, or use in another shareware
  519.           product such as doors and utilities where you allows others to try
  520.           the product first before buying and request a nominal registration
  521.           fee. Source code is available as an option for an additional $50.
  522.  
  523.           Registration of QBserial for commercial use is $75. Commercial uses
  524.           are: Inclusion of QBserial into ANY product that is to be sold for
  525.           profit, or any use of this program in a business environment. Any
  526.           program that must be paid for in advance before the product is
  527.           delivered, or use in a corporate environment fits this category.
  528.           Commercial registration includes the source code for QBserial in C
  529.           (Microsoft C), if desired.
  530.  
  531.           Please register your copy!
  532.  
  533.           Software and Shareware distribution houses may charge a nominal
  534.           distribution and copying fee not to exceed $5.00. They may not sell
  535.           this program outright or ask you for the registration fee directly,
  536.           they must inform you that registration is required by the author.
  537.  
  538.           If you have access to a BBS that is an ILINK mail network member,
  539.           you can reach me in the Basic conference. If you do not have ILINK
  540.           access anywhere nearby, then you can always contact me on the
  541.           SailBoard BBS at the number listed below. I would prefer if you
  542.           contact me directly on the SailBoard however, as ILINK isn't as
  543.           reliable as Id like, and I have missed messages. I'll do the best I
  544.           can to help if you have questions. Bugs will be tended to if
  545.           required, and good suggestions tend to be implemented.
  546.  
  547.  
  548.                                       Source Code
  549.  
  550.           The source code for QBserial is available. The source is available
  551.           by signing at the appropriate place on the registration form. The
  552.           source may be used for you own internal uses only. The source may
  553.           not be distributed by you to any other person, even if you make
  554.           changes to it. Nor can the resulting object code be sold or
  555.  
  556.  
  557.  
  558.  
  559.  
  560.  
  561.         QBSERIAL User Manual - V 2.10                             Page 10
  562.  
  563.  
  564.           distributed. Modifications can only be used in your end product,
  565.           and without any type of royalty. The source is available only after
  566.           you register QBserial. The license fee for the QBserial source code
  567.           is $50.00 for Non-Commercial users. Commercial users receive the
  568.           source as part of their registration fee if they desire it.
  569.  
  570.                                       Jeff Sumberg
  571.                                 Sysop(2) - SailBoard BBS
  572.                                 Wayne, NJ, 201-831-8152
  573.  
  574.                                         [ or ]
  575.  
  576.                                         Box 212
  577.                                   Ringwood, NJ, 07456
  578.  
  579.  
  580.  
  581.                                     Acknowledgments
  582.  
  583.           Thanks go out to Mark "Sparky" Herring for using these routines in
  584.           his highly successful Qmail door (versions 3 & 4).
  585.  
  586.           Thanks to Mark Wilson for some very good ideas in version 2.0.
  587.           Thanks to Michael Conley for finding a real time sensitive
  588.           interrupt problem.
  589.           Thanks to Jeffrey Morley (author of ZipLab) for testing.
  590.  
  591.  
  592.                                  Changes and Revisions
  593.  
  594.           06/09/89  1.0       Initial Release
  595.  
  596.           06/21/89  1.1       Added carrier detection control. Calling
  597.                               program can turn detection off and on as
  598.                               desired. Necessary if data sending/receiving
  599.                               required if carrier isn't present.
  600.  
  601.           09/01/89  1.2       Fixed a bug in Readchar where 'extended'
  602.                               characters (ASCII 128 to 255) were causing an
  603.                               Illegal Function Call in the CHR$() conversion
  604.                               (because they were being returned as negative
  605.                               numbers). Extended character may now be
  606.                               received properly. Added three new functions:
  607.                               CDtrap, CarrierLost, and DTRcontrol.
  608.  
  609.  
  610.           03/24/90  1.5       Added support for Basic Compiler 7.0 PDS and
  611.                               PDQ. Added sections to manual about Linking,
  612.                               Source code availability, and updated section
  613.                               on Quicklibs. Separate object files now
  614.                               supplied for QB, BC7, and PDQ.
  615.  
  616.  
  617.         QBSERIAL User Manual - V 2.10                             Page 11
  618.  
  619.  
  620.           05/01/90  1.6       Oops! PDQ users found out fast that I forgot to
  621.                               compile the PDQ module with stack checking
  622.                               removed. I also forgot to include ACRTUSED.OBJ
  623.                               to satisfy linking requirements. Sorry 'bout
  624.                               that! Released only as beta to those that
  625.                               needed it.
  626.  
  627.           11/01/90  2.0       Added capability to specify non-standard port
  628.                               addresses and which IRQ to use when the port is
  629.                               opened. Removed CDtrap function. Created new
  630.                               carrier detection modes using the CarrierDetect
  631.                               function. (0 = NONE, 1 = PARTIAL, 2 = FULL).
  632.                               Also added DriverCopyright function to allow
  633.                               program access to the driver version.
  634.  
  635.           02/08/92  2.10      Added RTS flow control support. RTS will be
  636.                               used to control data coming in to QBserial when
  637.                               the handshake is set to 2 (CTS/RTS). Removed
  638.                               necessity for SERIAL.LIB library file by adding
  639.                               inline assembler that performed the routines
  640.                               that were previously included in that library.
  641.                               QBserial is now compiled with Microsoft C 6.0
  642.                               which will give smaller, faster, and more
  643.                               efficient code than QuickC could generate. This
  644.                               is especially true in the interrupt area. Added
  645.                               new function RTScontrol, to allow program to
  646.                               control RTS line directly. Increased size of
  647.                               input buffer from 1024 to 2048 bytes. Changed
  648.                               method in which interrupt controller mask bits
  649.                               were set & cleared. Corrected error found in
  650.                               documentation describing the function of
  651.                               CarrierDetect.
  652.  
  653.  
  654.                                       Future Plans
  655.  
  656.           I hope in the not to near future to be able to add support for
  657.           extended interrupts (IRQs 8-15). There have been several requests
  658.           for this already.
  659.  
  660.           I also hope to be able to add support for the 16550A buffered UART.
  661.           This would make high speed communications much more reliable.
  662.  
  663.           I would also like to do a version of QBserial that can use two comm
  664.           ports simultaneously.
  665.  
  666.  
  667.  
  668.  
  669.  
  670.  
  671.  
  672.  
  673.         QBSERIAL User Manual - V 2.10                             Page 12